#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "Tir.h"

void initTir (Tir* ptir, const float tailleX, const float tailleY,
	const float posX, const float posY, Trajectoire* ptraj, const int tami)
{
	assert (ptir!=NULL && tailleX>0 && tailleY> 0 && posX>=0 && posY>=0
	       && ptraj!=NULL && tami>=0);
	ptir->tailleX_tir = tailleX;
	ptir->tailleY_tir = tailleY;
	ptir->posX_tir = posX;
	ptir->posY_tir = posY;
	ptir->ptraj_tir = ptraj;
	ptir->tir_ami = tami;
}

Tir* creerTir (const float tailleX, const float tailleY, const float posX, const float posY,
	       Trajectoire* ptraj, const int tami)
{
	assert (tailleX>0 && tailleY> 0 && ptraj!=NULL && posX>=0 && posY>=0&& tami>=0);
	Tir* ptir;
	ptir = (Tir*)malloc(sizeof(Tir));
	initTir(ptir, tailleX, tailleY, posX, posY, ptraj, tami);
	return ptir;
}

void libereTir (Tir* ptir)
{
	assert(ptir!=NULL);
	detruireTrajectoire(&(ptir->ptraj_tir));
	ptir = NULL;
}

void detruireTir (Tir** pptir)
{
	assert(pptir!=NULL);
	libereTir(*pptir);
	free(*pptir);
	*pptir = NULL;
}

const float getTailleXTir (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->tailleX_tir;
}

void setTailleXTir (Tir* ptir, const float tailleX)
{
	assert(ptir!=NULL && tailleX>0);
	ptir->tailleX_tir = tailleX;
}

const float getTailleYTir (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->tailleY_tir;
}

void setTailleYTir (Tir* ptir, const float tailleY)
{
	assert(ptir!=NULL && tailleY>0);
	ptir->tailleY_tir = tailleY;
}

const float getPosXTir (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->posX_tir;
}
  

void setPosXTir (Tir* ptir, const float posX)
{
	assert(ptir!=NULL);
	ptir->posX_tir = posX;
}

const float getPosYTir (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->posY_tir;
}

void setPosYTir (Tir* ptir, const float posY)
{
	assert(ptir!=NULL);
	ptir->posY_tir = posY;
}

Trajectoire* getTirTraj (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->ptraj_tir;
}

void setTirTraj (Tir* ptir, Trajectoire* ptraj)
{
	assert(ptir!=NULL && ptraj != NULL);
	ptir->ptraj_tir = ptraj;
}

const float getTirVitesse (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->ptraj_tir->vitesse1;
}

const float getTirVectx (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->ptraj_tir->vectx;
}

const float getTirVecty (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->ptraj_tir->vecty;
}
  
const int getTirAmi (const Tir* ptir)
{
	assert(ptir!=NULL);
	return ptir->tir_ami; //0 si le tir est ami normal, 1 si ennemi, 2 armeS1, 3 armeS2
}

void setTirAmi (Tir* ptir, const int tami)
{
	assert(ptir!=NULL);
	assert(tami == 0 || tami == 1 || tami == 2 || tami == 3);
	ptir->tir_ami = tami;
}

void deplacerTir (Tir* ptir)
{
	assert(ptir!=NULL);
	float t = getTirVitesse(ptir);
	float deplacementX=t*getTirVectx(ptir);
	float deplacementY=t*getTirVecty(ptir);
	setPosXTir(ptir, getPosXTir(ptir)+deplacementX);
	setPosYTir(ptir, getPosYTir(ptir)+deplacementY);
}

/** @brief Cette procedure permet de tester toutes les fonctions du module
 */
void testRegressionTir ()
{
	float res;
	Point* ppt1 = creerPoint (2, 4);
	Point* ppt2 = creerPoint (5, 10);
	float vit1 = 10;
	Trajectoire* ptraj = creerTrajectoire (ppt1, ppt2, vit1);
	Trajectoire* ptraj2 = creerTrajectoire (ppt2, ppt1, vit1);
	
	Tir* ptir = creerTir (2, 3, 1, 1, ptraj, 0);
	setTailleXTir (ptir, 4);
	res = getTailleXTir (ptir);
	if (res == 4)
		printf ("set/get TailleX fonctionne \n");
	else
		printf ("set/get TailleX ne fonctionne pas, t'es nul. \n");


	setTailleYTir (ptir, 5);
	res = getTailleYTir (ptir);
	if (res == 5)
		printf ("set/get TailleY fonctionne \n");
	else
		printf ("set/get TailleY ne fonctionne pas, t'es nul. \n");

	setTirTraj (ptir, ptraj2);
	ptraj = getTirTraj (ptir);

	if (ptraj == ptraj2)
		printf ("set/get Traj fonctionne \n");
	else
		printf ("set/get Traj ne fonctionne pas, t'es nul. \n");

	setTirAmi (ptir, 1);
	res = getTirAmi (ptir);
	if (res == 1)
		printf ("set/get Ami fonctionne \n");
	else
		printf ("set/get Ami ne fonctionne pas, t'es nul. \n");
		
	printf("posx: %f, posy: %f\n", getPosXTir(ptir), getPosYTir(ptir));
		
	deplacerTir (ptir);
	printf("le tir se déplace\n");
	
	printf("posx: %f, posy: %f\n", getPosXTir(ptir), getPosYTir(ptir));
		
	deplacerTir (ptir);
	printf("le tir se déplace\n");
	
	printf("posx: %f, posy: %f\n", getPosXTir(ptir), getPosYTir(ptir));
		
	deplacerTir (ptir);
	printf("le tir se déplace\n");
	
	printf("posx: %f, posy: %f\n", getPosXTir(ptir), getPosYTir(ptir));
	
	detruireTir (&ptir);

	if (ptir == NULL)
		printf ("set/get detruire fonctionne \n");
	else
		printf ("set/get detruire ne fonctionne pas, t'es nul. \n");

	
}
